package com.jingtao.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jingtao.mapper.ItemCatMapper;
import com.jingtao.pojo.ItemCat;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

@Service
public class ItemCatServiceImp implements ItemCatService{

    @Resource
    private ItemCatMapper itemCatMapper;



    /**
     * 利用Map集合封装所有的数据库记录
     * 封装数据：
     *      1、遍历所有的数据信息
     *      2、获取每一个parentId的值
     * @return
     */
    public Map<Integer,List<ItemCat>> getMap(){
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //查询所有的数据信息
        List<ItemCat> itemCatList = itemCatMapper.selectList(null);
        //将数据封装到map集合中
        for (ItemCat itemCat : itemCatList){
            Integer key = itemCat.getParentId();
            //判断map的集合中是否有值，没值：添加数据，将自己作为第一个元素填充
            //                     有值：获取List集合，将自己追加到其中
            if (map.containsKey(key)){
                map.get(key).add(itemCat);
            }else {
                List<ItemCat> list = new ArrayList<>();
                list.add(itemCat);
                map.put(key, list);
            }
        }
        return map;
    }


    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        Map<Integer,List<ItemCat>> map = getMap();
        //根据level获取子级的信息，
        if (level == 1){//只获取一级列表信息
            return map.get(0);
        }
        if (level == 2){
            return getTwoList(map);
        }

        return getThreeList(map);

//        //查询一级菜单
//        QueryWrapper queryWrapper = new QueryWrapper();
//        queryWrapper.eq("parent_id",0);
//        List<ItemCat> itemCatList = itemCatMapper.selectList(queryWrapper);
//        //查询二级菜单 二级数据是一级数据的子级，封装到一级数据中
//        for(ItemCat oneItemCat :itemCatList){
//            int oneId = oneItemCat.getId();//一级对象ID
//            //清空原始条件
//            queryWrapper.clear();
//            queryWrapper.eq("parent_id",oneId);
//            List<ItemCat> itemCatList1 = itemCatMapper.selectList(queryWrapper);
//            //将二级的数据封装到一级的对象中
//            oneItemCat.setChildren(itemCatList1);
//            //查询三级列表
//            for(ItemCat twoItemCat : itemCatList1){
//                int twoId = twoItemCat.getId();
//                queryWrapper.clear();
//                queryWrapper.eq("parent_id",twoId);
//                List<ItemCat> itemCatList2 = itemCatMapper.selectList(queryWrapper);
//                //将三级列表封装到二级的对象中
//                twoItemCat.setChildren(itemCatList2);
//            }
//        }
    }

    //获取三级列表信息，先获取一级数据，再获取二级数据，再获取三级数据
    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
        //调用二级的菜单
        List<ItemCat> oneList = getTwoList(map);
        //遍历一级集合，获取二级数据，封装三级菜单
        for (ItemCat itemCatone : oneList){
            //获取二级数据
            List<ItemCat> twoList = itemCatone.getChildren();
            if (twoList == null || twoList.size()==0){
                //判断二级集合是否为null，如果为null，表示没有二级菜单
                continue;
            }
            for (ItemCat twoItemCat : twoList){
                Integer twoId = twoItemCat.getId();
                List<ItemCat> threeList = map.get(twoId);
                twoItemCat.setChildren(threeList);
            }
        }
        return oneList;
    }

    private List<ItemCat> getTwoList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> oneList = map.get(0);
        //获取二级信息，应该先遍历一级集合
        for (ItemCat itemCatone : oneList){
            int id = itemCatone.getId();
            //根据一级Id，获取二级集合
            List<ItemCat> twoList = map.get(id);
            itemCatone.setChildren(twoList);
        }
        return oneList;
    }

    @Override
    @Transactional//事物的控制
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);
        itemCatMapper.insert(itemCat);
    }
    @Transactional
    @Override
    public void deleteItemCat(Integer id, Integer level) {
        //判断是否为3级菜单
        if(level == 3){
            itemCatMapper.deleteById(id);
        }
        if (level == 2){
            //如果是二级，应该先获取三级数据之后删除，然后再删除自己
            //delete from item_cat where parent_id =#{id} or id = #{id}
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", id)
                        .or()
                        .eq("id",id);
            itemCatMapper.delete(queryWrapper);
        }
        /**
         * 删除一级菜单
         * 获取二级ID
         * 终结SQL：delete from item_cat where parent_id in(twoIds) or id in(twoIds) or id = #{id}
         */
        if (level == 1){
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", id);
            List twoIds = itemCatMapper.selectObjs(queryWrapper);
            queryWrapper.clear();
            //规则：如果2级菜单有值，才会删除
            queryWrapper.in(twoIds.size()>0,"parent_id",twoIds)
                        .or()
                        .in(twoIds.size()>0,"id",twoIds)
                        .or()
                        .eq("id",id);
            itemCatMapper.delete(queryWrapper);
        }
    }

    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {
        UpdateWrapper<ItemCat> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", itemCat.getId());
        itemCatMapper.update(itemCat,updateWrapper);
    }

    @Override
    @Transactional
    public void status(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }
}
